// cmath standard header
#pragma once
#ifndef _CMATH_
#define _CMATH_
#ifndef RC_INVOKED

#include <yvals.h>

#include <cstdlib>

#pragma pack(push, _CRT_PACKING)
#pragma warning(push, _STL_WARNING_LEVEL)
#pragma warning(disable : _STL_DISABLED_WARNINGS)
_STL_DISABLE_CLANG_WARNINGS
#pragma push_macro("new")
#undef new

_Check_return_ inline double pow(_In_ double _Xx, _In_ int _Yx) noexcept {
    if (_Yx == 2) {
        return _Xx * _Xx;
    }

    return _CSTD pow(_Xx, static_cast<double>(_Yx));
}

_Check_return_ inline float acos(_In_ float _Xx) noexcept {
    return _CSTD acosf(_Xx);
}

_Check_return_ inline float acosh(_In_ float _Xx) noexcept {
    return _CSTD acoshf(_Xx);
}

_Check_return_ inline float asin(_In_ float _Xx) noexcept {
    return _CSTD asinf(_Xx);
}

_Check_return_ inline float asinh(_In_ float _Xx) noexcept {
    return _CSTD asinhf(_Xx);
}

_Check_return_ inline float atan(_In_ float _Xx) noexcept {
    return _CSTD atanf(_Xx);
}

_Check_return_ inline float atanh(_In_ float _Xx) noexcept {
    return _CSTD atanhf(_Xx);
}

_Check_return_ inline float atan2(_In_ float _Yx, _In_ float _Xx) noexcept {
    return _CSTD atan2f(_Yx, _Xx);
}

_Check_return_ inline float cbrt(_In_ float _Xx) noexcept {
    return _CSTD cbrtf(_Xx);
}

_Check_return_ inline float ceil(_In_ float _Xx) noexcept {
    return _CSTD ceilf(_Xx);
}

_Check_return_ inline float copysign(_In_ float _Number, _In_ float _Sign) noexcept {
    return _CSTD copysignf(_Number, _Sign);
}

_Check_return_ inline float cos(_In_ float _Xx) noexcept {
    return _CSTD cosf(_Xx);
}

_Check_return_ inline float cosh(_In_ float _Xx) noexcept {
    return _CSTD coshf(_Xx);
}

_Check_return_ inline float erf(_In_ float _Xx) noexcept {
    return _CSTD erff(_Xx);
}

_Check_return_ inline float erfc(_In_ float _Xx) noexcept {
    return _CSTD erfcf(_Xx);
}

_Check_return_ inline float exp(_In_ float _Xx) noexcept {
    return _CSTD expf(_Xx);
}

_Check_return_ inline float exp2(_In_ float _Xx) noexcept {
    return _CSTD exp2f(_Xx);
}

_Check_return_ inline float expm1(_In_ float _Xx) noexcept {
    return _CSTD expm1f(_Xx);
}

_Check_return_ inline float fabs(_In_ float _Xx) noexcept {
    return _CSTD fabsf(_Xx);
}

_Check_return_ inline float fdim(_In_ float _Xx, _In_ float _Yx) noexcept {
    return _CSTD fdimf(_Xx, _Yx);
}

_Check_return_ inline float floor(_In_ float _Xx) noexcept {
    return _CSTD floorf(_Xx);
}

_Check_return_ inline float fma(_In_ float _Xx, _In_ float _Yx, _In_ float _Zx) noexcept {
    return _CSTD fmaf(_Xx, _Yx, _Zx);
}

_Check_return_ inline float fmax(_In_ float _Xx, _In_ float _Yx) noexcept {
    return _CSTD fmaxf(_Xx, _Yx);
}

_Check_return_ inline float fmin(_In_ float _Xx, _In_ float _Yx) noexcept {
    return _CSTD fminf(_Xx, _Yx);
}

_Check_return_ inline float fmod(_In_ float _Xx, _In_ float _Yx) noexcept {
    return _CSTD fmodf(_Xx, _Yx);
}

_Check_return_ inline float frexp(_In_ float _Xx, _Out_ int* _Yx) noexcept {
    return _CSTD frexpf(_Xx, _Yx);
}

_Check_return_ inline float hypot(_In_ float _Xx, _In_ float _Yx) noexcept {
    return _CSTD hypotf(_Xx, _Yx);
}

_Check_return_ inline int ilogb(_In_ float _Xx) noexcept {
    return _CSTD ilogbf(_Xx);
}

_Check_return_ inline float ldexp(_In_ float _Xx, _In_ int _Yx) noexcept {
    return _CSTD ldexpf(_Xx, _Yx);
}

_Check_return_ inline float lgamma(_In_ float _Xx) noexcept {
    return _CSTD lgammaf(_Xx);
}

_Check_return_ inline long long llrint(_In_ float _Xx) noexcept {
    return _CSTD llrintf(_Xx);
}

_Check_return_ inline long long llround(_In_ float _Xx) noexcept {
    return _CSTD llroundf(_Xx);
}

_Check_return_ inline float log(_In_ float _Xx) noexcept {
    return _CSTD logf(_Xx);
}

_Check_return_ inline float log10(_In_ float _Xx) noexcept {
    return _CSTD log10f(_Xx);
}

_Check_return_ inline float log1p(_In_ float _Xx) noexcept {
    return _CSTD log1pf(_Xx);
}

_Check_return_ inline float log2(_In_ float _Xx) noexcept {
    return _CSTD log2f(_Xx);
}

_Check_return_ inline float logb(_In_ float _Xx) noexcept {
    return _CSTD logbf(_Xx);
}

_Check_return_ inline long lrint(_In_ float _Xx) noexcept {
    return _CSTD lrintf(_Xx);
}

_Check_return_ inline long lround(_In_ float _Xx) noexcept {
    return _CSTD lroundf(_Xx);
}

_Check_return_ inline float modf(_In_ float _Xx, _Out_ float* _Yx) noexcept {
    return _CSTD modff(_Xx, _Yx);
}

_Check_return_ inline float nearbyint(_In_ float _Xx) noexcept {
    return _CSTD nearbyintf(_Xx);
}

_Check_return_ inline float nextafter(_In_ float _Xx, _In_ float _Yx) noexcept {
    return _CSTD nextafterf(_Xx, _Yx);
}

_Check_return_ inline float nexttoward(_In_ float _Xx, _In_ long double _Yx) noexcept {
    return _CSTD nexttowardf(_Xx, _Yx);
}

_Check_return_ inline float pow(_In_ float _Xx, _In_ float _Yx) noexcept {
    return _CSTD powf(_Xx, _Yx);
}

_Check_return_ inline float pow(_In_ float _Xx, _In_ int _Yx) noexcept {
    if (_Yx == 2) {
        return _Xx * _Xx;
    }

    return _CSTD powf(_Xx, static_cast<float>(_Yx));
}

_Check_return_ inline float remainder(_In_ float _Xx, _In_ float _Yx) noexcept {
    return _CSTD remainderf(_Xx, _Yx);
}

_Check_return_ inline float remquo(_In_ float _Xx, _In_ float _Yx, _Out_ int* _Zx) noexcept {
    return _CSTD remquof(_Xx, _Yx, _Zx);
}

_Check_return_ inline float rint(_In_ float _Xx) noexcept {
    return _CSTD rintf(_Xx);
}

_Check_return_ inline float round(_In_ float _Xx) noexcept {
    return _CSTD roundf(_Xx);
}

_Check_return_ inline float scalbln(_In_ float _Xx, _In_ long _Yx) noexcept {
    return _CSTD scalblnf(_Xx, _Yx);
}

_Check_return_ inline float scalbn(_In_ float _Xx, _In_ int _Yx) noexcept {
    return _CSTD scalbnf(_Xx, _Yx);
}

_Check_return_ inline float sin(_In_ float _Xx) noexcept {
    return _CSTD sinf(_Xx);
}

_Check_return_ inline float sinh(_In_ float _Xx) noexcept {
    return _CSTD sinhf(_Xx);
}

_Check_return_ inline float sqrt(_In_ float _Xx) noexcept {
    return _CSTD sqrtf(_Xx);
}

_Check_return_ inline float tan(_In_ float _Xx) noexcept {
    return _CSTD tanf(_Xx);
}

_Check_return_ inline float tanh(_In_ float _Xx) noexcept {
    return _CSTD tanhf(_Xx);
}

_Check_return_ inline float tgamma(_In_ float _Xx) noexcept {
    return _CSTD tgammaf(_Xx);
}

_Check_return_ inline float trunc(_In_ float _Xx) noexcept {
    return _CSTD truncf(_Xx);
}

_Check_return_ inline long double acos(_In_ long double _Xx) noexcept {
    return _CSTD acosl(_Xx);
}

_Check_return_ inline long double acosh(_In_ long double _Xx) noexcept {
    return _CSTD acoshl(_Xx);
}

_Check_return_ inline long double asin(_In_ long double _Xx) noexcept {
    return _CSTD asinl(_Xx);
}

_Check_return_ inline long double asinh(_In_ long double _Xx) noexcept {
    return _CSTD asinhl(_Xx);
}

_Check_return_ inline long double atan(_In_ long double _Xx) noexcept {
    return _CSTD atanl(_Xx);
}

_Check_return_ inline long double atanh(_In_ long double _Xx) noexcept {
    return _CSTD atanhl(_Xx);
}

_Check_return_ inline long double atan2(_In_ long double _Yx, _In_ long double _Xx) noexcept {
    return _CSTD atan2l(_Yx, _Xx);
}

_Check_return_ inline long double cbrt(_In_ long double _Xx) noexcept {
    return _CSTD cbrtl(_Xx);
}

_Check_return_ inline long double ceil(_In_ long double _Xx) noexcept {
    return _CSTD ceill(_Xx);
}

_Check_return_ inline long double copysign(_In_ long double _Number, _In_ long double _Sign) noexcept {
    return _CSTD copysignl(_Number, _Sign);
}

_Check_return_ inline long double cos(_In_ long double _Xx) noexcept {
    return _CSTD cosl(_Xx);
}

_Check_return_ inline long double cosh(_In_ long double _Xx) noexcept {
    return _CSTD coshl(_Xx);
}

_Check_return_ inline long double erf(_In_ long double _Xx) noexcept {
    return _CSTD erfl(_Xx);
}

_Check_return_ inline long double erfc(_In_ long double _Xx) noexcept {
    return _CSTD erfcl(_Xx);
}

_Check_return_ inline long double exp(_In_ long double _Xx) noexcept {
    return _CSTD expl(_Xx);
}

_Check_return_ inline long double exp2(_In_ long double _Xx) noexcept {
    return _CSTD exp2l(_Xx);
}

_Check_return_ inline long double expm1(_In_ long double _Xx) noexcept {
    return _CSTD expm1l(_Xx);
}

_Check_return_ inline long double fabs(_In_ long double _Xx) noexcept {
    return _CSTD fabsl(_Xx);
}

_Check_return_ inline long double fdim(_In_ long double _Xx, _In_ long double _Yx) noexcept {
    return _CSTD fdiml(_Xx, _Yx);
}

_Check_return_ inline long double floor(_In_ long double _Xx) noexcept {
    return _CSTD floorl(_Xx);
}

_Check_return_ inline long double fma(_In_ long double _Xx, _In_ long double _Yx, _In_ long double _Zx) noexcept {
    return _CSTD fmal(_Xx, _Yx, _Zx);
}

_Check_return_ inline long double fmax(_In_ long double _Xx, _In_ long double _Yx) noexcept {
    return _CSTD fmaxl(_Xx, _Yx);
}

_Check_return_ inline long double fmin(_In_ long double _Xx, _In_ long double _Yx) noexcept {
    return _CSTD fminl(_Xx, _Yx);
}

_Check_return_ inline long double fmod(_In_ long double _Xx, _In_ long double _Yx) noexcept {
    return _CSTD fmodl(_Xx, _Yx);
}

_Check_return_ inline long double frexp(_In_ long double _Xx, _Out_ int* _Yx) noexcept {
    return _CSTD frexpl(_Xx, _Yx);
}

_Check_return_ inline long double hypot(_In_ long double _Xx, _In_ long double _Yx) noexcept {
    return _CSTD hypotl(_Xx, _Yx);
}

_Check_return_ inline int ilogb(_In_ long double _Xx) noexcept {
    return _CSTD ilogbl(_Xx);
}

_Check_return_ inline long double ldexp(_In_ long double _Xx, _In_ int _Yx) noexcept {
    return _CSTD ldexpl(_Xx, _Yx);
}

_Check_return_ inline long double lgamma(_In_ long double _Xx) noexcept {
    return _CSTD lgammal(_Xx);
}

_Check_return_ inline long long llrint(_In_ long double _Xx) noexcept {
    return _CSTD llrintl(_Xx);
}

_Check_return_ inline long long llround(_In_ long double _Xx) noexcept {
    return _CSTD llroundl(_Xx);
}

_Check_return_ inline long double log(_In_ long double _Xx) noexcept {
    return _CSTD logl(_Xx);
}

_Check_return_ inline long double log10(_In_ long double _Xx) noexcept {
    return _CSTD log10l(_Xx);
}

_Check_return_ inline long double log1p(_In_ long double _Xx) noexcept {
    return _CSTD log1pl(_Xx);
}

_Check_return_ inline long double log2(_In_ long double _Xx) noexcept {
    return _CSTD log2l(_Xx);
}

_Check_return_ inline long double logb(_In_ long double _Xx) noexcept {
    return _CSTD logbl(_Xx);
}

_Check_return_ inline long lrint(_In_ long double _Xx) noexcept {
    return _CSTD lrintl(_Xx);
}

_Check_return_ inline long lround(_In_ long double _Xx) noexcept {
    return _CSTD lroundl(_Xx);
}

_Check_return_ inline long double modf(_In_ long double _Xx, _Out_ long double* _Yx) noexcept {
    return _CSTD modfl(_Xx, _Yx);
}

_Check_return_ inline long double nearbyint(_In_ long double _Xx) noexcept {
    return _CSTD nearbyintl(_Xx);
}

_Check_return_ inline long double nextafter(_In_ long double _Xx, _In_ long double _Yx) noexcept {
    return _CSTD nextafterl(_Xx, _Yx);
}

_Check_return_ inline long double nexttoward(_In_ long double _Xx, _In_ long double _Yx) noexcept {
    return _CSTD nexttowardl(_Xx, _Yx);
}

_Check_return_ inline long double pow(_In_ long double _Xx, _In_ long double _Yx) noexcept {
    return _CSTD powl(_Xx, _Yx);
}

_Check_return_ inline long double pow(_In_ long double _Xx, _In_ int _Yx) noexcept {
    if (_Yx == 2) {
        return _Xx * _Xx;
    }

    return _CSTD powl(_Xx, static_cast<long double>(_Yx));
}

_Check_return_ inline long double remainder(_In_ long double _Xx, _In_ long double _Yx) noexcept {
    return _CSTD remainderl(_Xx, _Yx);
}

_Check_return_ inline long double remquo(_In_ long double _Xx, _In_ long double _Yx, _Out_ int* _Zx) noexcept {
    return _CSTD remquol(_Xx, _Yx, _Zx);
}

_Check_return_ inline long double rint(_In_ long double _Xx) noexcept {
    return _CSTD rintl(_Xx);
}

_Check_return_ inline long double round(_In_ long double _Xx) noexcept {
    return _CSTD roundl(_Xx);
}

_Check_return_ inline long double scalbln(_In_ long double _Xx, _In_ long _Yx) noexcept {
    return _CSTD scalblnl(_Xx, _Yx);
}

_Check_return_ inline long double scalbn(_In_ long double _Xx, _In_ int _Yx) noexcept {
    return _CSTD scalbnl(_Xx, _Yx);
}

_Check_return_ inline long double sin(_In_ long double _Xx) noexcept {
    return _CSTD sinl(_Xx);
}

_Check_return_ inline long double sinh(_In_ long double _Xx) noexcept {
    return _CSTD sinhl(_Xx);
}

_Check_return_ inline long double sqrt(_In_ long double _Xx) noexcept {
    return _CSTD sqrtl(_Xx);
}

_Check_return_ inline long double tan(_In_ long double _Xx) noexcept {
    return _CSTD tanl(_Xx);
}

_Check_return_ inline long double tanh(_In_ long double _Xx) noexcept {
    return _CSTD tanhl(_Xx);
}

_Check_return_ inline long double tgamma(_In_ long double _Xx) noexcept {
    return _CSTD tgammal(_Xx);
}

_Check_return_ inline long double trunc(_In_ long double _Xx) noexcept {
    return _CSTD truncl(_Xx);
}

#include <xtgmath.h>

_STD_BEGIN
using _CSTD abs;
using _CSTD acos;
using _CSTD asin;
using _CSTD atan;
using _CSTD atan2;
using _CSTD ceil;
using _CSTD cos;
using _CSTD cosh;
using _CSTD exp;
using _CSTD fabs;
using _CSTD floor;
using _CSTD fmod;
using _CSTD frexp;
using _CSTD ldexp;
using _CSTD log;
using _CSTD log10;
using _CSTD modf;
using _CSTD pow;
using _CSTD sin;
using _CSTD sinh;
using _CSTD sqrt;
using _CSTD tan;
using _CSTD tanh;

using _CSTD acosf;
using _CSTD asinf;
using _CSTD atanf;
using _CSTD atan2f;
using _CSTD ceilf;
using _CSTD cosf;
using _CSTD coshf;
using _CSTD expf;
using _CSTD fabsf;
using _CSTD floorf;
using _CSTD fmodf;
using _CSTD frexpf;
using _CSTD ldexpf;
using _CSTD logf;
using _CSTD log10f;
using _CSTD modff;
using _CSTD powf;
using _CSTD sinf;
using _CSTD sinhf;
using _CSTD sqrtf;
using _CSTD tanf;
using _CSTD tanhf;

using _CSTD acosl;
using _CSTD asinl;
using _CSTD atanl;
using _CSTD atan2l;
using _CSTD ceill;
using _CSTD cosl;
using _CSTD coshl;
using _CSTD expl;
using _CSTD fabsl;
using _CSTD floorl;
using _CSTD fmodl;
using _CSTD frexpl;
using _CSTD ldexpl;
using _CSTD logl;
using _CSTD log10l;
using _CSTD modfl;
using _CSTD powl;
using _CSTD sinl;
using _CSTD sinhl;
using _CSTD sqrtl;
using _CSTD tanl;
using _CSTD tanhl;

using _CSTD float_t;
using _CSTD double_t;

using _CSTD acosh;
using _CSTD asinh;
using _CSTD atanh;
using _CSTD cbrt;
using _CSTD erf;
using _CSTD erfc;
using _CSTD expm1;
using _CSTD exp2;
using _CSTD hypot;
using _CSTD ilogb;
using _CSTD lgamma;
using _CSTD log1p;
using _CSTD log2;
using _CSTD logb;
using _CSTD llrint;
using _CSTD lrint;
using _CSTD nearbyint;
using _CSTD rint;
using _CSTD llround;
using _CSTD lround;
using _CSTD fdim;
using _CSTD fma;
using _CSTD fmax;
using _CSTD fmin;
using _CSTD round;
using _CSTD trunc;
using _CSTD remainder;
using _CSTD remquo;
using _CSTD copysign;
using _CSTD nan;
using _CSTD nextafter;
using _CSTD scalbn;
using _CSTD scalbln;
using _CSTD nexttoward;
using _CSTD tgamma;

using _CSTD acoshf;
using _CSTD asinhf;
using _CSTD atanhf;
using _CSTD cbrtf;
using _CSTD erff;
using _CSTD erfcf;
using _CSTD expm1f;
using _CSTD exp2f;
using _CSTD hypotf;
using _CSTD ilogbf;
using _CSTD lgammaf;
using _CSTD log1pf;
using _CSTD log2f;
using _CSTD logbf;
using _CSTD llrintf;
using _CSTD lrintf;
using _CSTD nearbyintf;
using _CSTD rintf;
using _CSTD llroundf;
using _CSTD lroundf;
using _CSTD fdimf;
using _CSTD fmaf;
using _CSTD fmaxf;
using _CSTD fminf;
using _CSTD roundf;
using _CSTD truncf;
using _CSTD remainderf;
using _CSTD remquof;
using _CSTD copysignf;
using _CSTD nanf;
using _CSTD nextafterf;
using _CSTD scalbnf;
using _CSTD scalblnf;
using _CSTD nexttowardf;
using _CSTD tgammaf;

using _CSTD acoshl;
using _CSTD asinhl;
using _CSTD atanhl;
using _CSTD cbrtl;
using _CSTD erfl;
using _CSTD erfcl;
using _CSTD expm1l;
using _CSTD exp2l;
using _CSTD hypotl;
using _CSTD ilogbl;
using _CSTD lgammal;
using _CSTD log1pl;
using _CSTD log2l;
using _CSTD logbl;
using _CSTD llrintl;
using _CSTD lrintl;
using _CSTD nearbyintl;
using _CSTD rintl;
using _CSTD llroundl;
using _CSTD lroundl;
using _CSTD fdiml;
using _CSTD fmal;
using _CSTD fmaxl;
using _CSTD fminl;
using _CSTD roundl;
using _CSTD truncl;
using _CSTD remainderl;
using _CSTD remquol;
using _CSTD copysignl;
using _CSTD nanl;
using _CSTD nextafterl;
using _CSTD scalbnl;
using _CSTD scalblnl;
using _CSTD nexttowardl;
using _CSTD tgammal;

using _CSTD fpclassify;
using _CSTD signbit;
using _CSTD isfinite;
using _CSTD isinf;
using _CSTD isnan;
using _CSTD isnormal;
using _CSTD isgreater;
using _CSTD isgreaterequal;
using _CSTD isless;
using _CSTD islessequal;
using _CSTD islessgreater;
using _CSTD isunordered;
_STD_END

#if _HAS_CXX17
_EXTERN_C
_CRTIMP4 _NODISCARD double __stdcall __std_smf_assoc_laguerre(unsigned int, unsigned int, double) noexcept;
_CRTIMP4 _NODISCARD float __stdcall __std_smf_assoc_laguerref(unsigned int, unsigned int, float) noexcept;
_CRTIMP4 _NODISCARD double __stdcall __std_smf_assoc_legendre(unsigned int, unsigned int, double) noexcept;
_CRTIMP4 _NODISCARD float __stdcall __std_smf_assoc_legendref(unsigned int, unsigned int, float) noexcept;
_CRTIMP4 _NODISCARD double __stdcall __std_smf_beta(double, double) noexcept;
_CRTIMP4 _NODISCARD float __stdcall __std_smf_betaf(float, float) noexcept;
_CRTIMP4 _NODISCARD double __stdcall __std_smf_comp_ellint_1(double) noexcept;
_CRTIMP4 _NODISCARD float __stdcall __std_smf_comp_ellint_1f(float) noexcept;
_CRTIMP4 _NODISCARD double __stdcall __std_smf_comp_ellint_2(double) noexcept;
_CRTIMP4 _NODISCARD float __stdcall __std_smf_comp_ellint_2f(float) noexcept;
_CRTIMP4 _NODISCARD double __stdcall __std_smf_comp_ellint_3(double, double) noexcept;
_CRTIMP4 _NODISCARD float __stdcall __std_smf_comp_ellint_3f(float, float) noexcept;
_CRTIMP4 _NODISCARD double __stdcall __std_smf_cyl_bessel_i(double, double) noexcept;
_CRTIMP4 _NODISCARD float __stdcall __std_smf_cyl_bessel_if(float, float) noexcept;
_CRTIMP4 _NODISCARD double __stdcall __std_smf_cyl_bessel_j(double, double) noexcept;
_CRTIMP4 _NODISCARD float __stdcall __std_smf_cyl_bessel_jf(float, float) noexcept;
_CRTIMP4 _NODISCARD double __stdcall __std_smf_cyl_bessel_k(double, double) noexcept;
_CRTIMP4 _NODISCARD float __stdcall __std_smf_cyl_bessel_kf(float, float) noexcept;
_CRTIMP4 _NODISCARD double __stdcall __std_smf_cyl_neumann(double, double) noexcept;
_CRTIMP4 _NODISCARD float __stdcall __std_smf_cyl_neumannf(float, float) noexcept;
_CRTIMP4 _NODISCARD double __stdcall __std_smf_ellint_1(double, double) noexcept;
_CRTIMP4 _NODISCARD float __stdcall __std_smf_ellint_1f(float, float) noexcept;
_CRTIMP4 _NODISCARD double __stdcall __std_smf_ellint_2(double, double) noexcept;
_CRTIMP4 _NODISCARD float __stdcall __std_smf_ellint_2f(float, float) noexcept;
_CRTIMP4 _NODISCARD double __stdcall __std_smf_ellint_3(double, double, double) noexcept;
_CRTIMP4 _NODISCARD float __stdcall __std_smf_ellint_3f(float, float, float) noexcept;
_CRTIMP4 _NODISCARD double __stdcall __std_smf_expint(double) noexcept;
_CRTIMP4 _NODISCARD float __stdcall __std_smf_expintf(float) noexcept;
_CRTIMP4 _NODISCARD double __stdcall __std_smf_hermite(unsigned int, double) noexcept;
_CRTIMP4 _NODISCARD float __stdcall __std_smf_hermitef(unsigned int, float) noexcept;
_CRTIMP4 _NODISCARD double __stdcall __std_smf_laguerre(unsigned int, double) noexcept;
_CRTIMP4 _NODISCARD float __stdcall __std_smf_laguerref(unsigned int, float) noexcept;
_CRTIMP4 _NODISCARD double __stdcall __std_smf_legendre(unsigned int, double) noexcept;
_CRTIMP4 _NODISCARD float __stdcall __std_smf_legendref(unsigned int, float) noexcept;
_CRTIMP4 _NODISCARD double __stdcall __std_smf_riemann_zeta(double) noexcept;
_CRTIMP4 _NODISCARD float __stdcall __std_smf_riemann_zetaf(float) noexcept;
_CRTIMP4 _NODISCARD double __stdcall __std_smf_sph_bessel(unsigned int, double) noexcept;
_CRTIMP4 _NODISCARD float __stdcall __std_smf_sph_besself(unsigned int, float) noexcept;
_CRTIMP4 _NODISCARD double __stdcall __std_smf_sph_legendre(unsigned int, unsigned int, double) noexcept;
_CRTIMP4 _NODISCARD float __stdcall __std_smf_sph_legendref(unsigned int, unsigned int, float) noexcept;
_CRTIMP4 _NODISCARD double __stdcall __std_smf_sph_neumann(unsigned int, double) noexcept;
_CRTIMP4 _NODISCARD float __stdcall __std_smf_sph_neumannf(unsigned int, float) noexcept;
_CRTIMP4 _NODISCARD double __stdcall __std_smf_hypot3(double, double, double) noexcept;
_CRTIMP4 _NODISCARD float __stdcall __std_smf_hypot3f(float, float, float) noexcept;
_END_EXTERN_C

_STD_BEGIN
#if _HAS_SPECIAL_MATH
// FUNCTION assoc_laguerre
_NODISCARD inline double assoc_laguerre(const unsigned int _Degree, const unsigned int _Order, const double _Value) {
    return __std_smf_assoc_laguerre(_Degree, _Order, _Value);
}

// FUNCTION assoc_laguerref
_NODISCARD inline float assoc_laguerref(const unsigned int _Degree, const unsigned int _Order, const float _Value) {
    return __std_smf_assoc_laguerref(_Degree, _Order, _Value);
}

// FUNCTION assoc_laguerrel
_NODISCARD inline long double assoc_laguerrel(
    const unsigned int _Degree, const unsigned int _Order, const long double _Value) {
    return __std_smf_assoc_laguerre(_Degree, _Order, static_cast<double>(_Value));
}

// FUNCTION assoc_legendre
_NODISCARD inline double assoc_legendre(const unsigned int _Degree, const unsigned int _Order, const double _Value) {
    return __std_smf_assoc_legendre(_Degree, _Order, _Value);
}

// FUNCTION assoc_legendref
_NODISCARD inline float assoc_legendref(const unsigned int _Degree, const unsigned int _Order, const float _Value) {
    return __std_smf_assoc_legendref(_Degree, _Order, _Value);
}

// FUNCTION assoc_legendrel
_NODISCARD inline long double assoc_legendrel(
    const unsigned int _Degree, const unsigned int _Order, const long double _Value) {
    return __std_smf_assoc_legendre(_Degree, _Order, static_cast<double>(_Value));
}

// FUNCTION beta
_NODISCARD inline double beta(const double _Arg1, const double _Arg2) {
    return __std_smf_beta(_Arg1, _Arg2);
}

// FUNCTION betaf
_NODISCARD inline float betaf(const float _Arg1, const float _Arg2) {
    return __std_smf_betaf(_Arg1, _Arg2);
}

// FUNCTION betal
_NODISCARD inline long double betal(const long double _Arg1, const long double _Arg2) {
    return __std_smf_beta(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

// FUNCTION comp_ellint_1
_NODISCARD inline double comp_ellint_1(const double _Arg) {
    return __std_smf_comp_ellint_1(_Arg);
}

// FUNCTION comp_ellint_1f
_NODISCARD inline float comp_ellint_1f(const float _Arg) {
    return __std_smf_comp_ellint_1f(_Arg);
}

// FUNCTION comp_ellint_1l
_NODISCARD inline long double comp_ellint_1l(const long double _Arg) {
    return __std_smf_comp_ellint_1(static_cast<double>(_Arg));
}

// FUNCTION comp_ellint_2
_NODISCARD inline double comp_ellint_2(const double _Arg) {
    return __std_smf_comp_ellint_2(_Arg);
}

// FUNCTION comp_ellint_2f
_NODISCARD inline float comp_ellint_2f(const float _Arg) {
    return __std_smf_comp_ellint_2f(_Arg);
}

// FUNCTION comp_ellint_2l
_NODISCARD inline long double comp_ellint_2l(const long double _Arg) {
    return __std_smf_comp_ellint_2(static_cast<double>(_Arg));
}

// FUNCTION comp_ellint_3
_NODISCARD inline double comp_ellint_3(const double _Arg1, const double _Arg2) {
    return __std_smf_comp_ellint_3(_Arg1, _Arg2);
}

// FUNCTION comp_ellint_3f
_NODISCARD inline float comp_ellint_3f(const float _Arg1, const float _Arg2) {
    return __std_smf_comp_ellint_3f(_Arg1, _Arg2);
}

// FUNCTION comp_ellint_3l
_NODISCARD inline long double comp_ellint_3l(const long double _Arg1, const long double _Arg2) {
    return __std_smf_comp_ellint_3(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

// FUNCTION cyl_bessel_i
_NODISCARD inline double cyl_bessel_i(const double _Arg1, const double _Arg2) {
    return __std_smf_cyl_bessel_i(_Arg1, _Arg2);
}

// FUNCTION cyl_bessel_if
_NODISCARD inline float cyl_bessel_if(const float _Arg1, const float _Arg2) {
    return __std_smf_cyl_bessel_if(_Arg1, _Arg2);
}

// FUNCTION cyl_bessel_il
_NODISCARD inline long double cyl_bessel_il(const long double _Arg1, const long double _Arg2) {
    return __std_smf_cyl_bessel_i(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

// FUNCTION cyl_bessel_j
_NODISCARD inline double cyl_bessel_j(const double _Arg1, const double _Arg2) {
    return __std_smf_cyl_bessel_j(_Arg1, _Arg2);
}

// FUNCTION cyl_bessel_jf
_NODISCARD inline float cyl_bessel_jf(const float _Arg1, const float _Arg2) {
    return __std_smf_cyl_bessel_jf(_Arg1, _Arg2);
}

// FUNCTION cyl_bessel_jl
_NODISCARD inline long double cyl_bessel_jl(const long double _Arg1, const long double _Arg2) {
    return __std_smf_cyl_bessel_j(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

// FUNCTION cyl_bessel_k
_NODISCARD inline double cyl_bessel_k(const double _Arg1, const double _Arg2) {
    return __std_smf_cyl_bessel_k(_Arg1, _Arg2);
}

// FUNCTION cyl_bessel_kf
_NODISCARD inline float cyl_bessel_kf(const float _Arg1, const float _Arg2) {
    return __std_smf_cyl_bessel_kf(_Arg1, _Arg2);
}

// FUNCTION cyl_bessel_kl
_NODISCARD inline long double cyl_bessel_kl(const long double _Arg1, const long double _Arg2) {
    return __std_smf_cyl_bessel_k(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

// FUNCTION cyl_neumann
_NODISCARD inline double cyl_neumann(const double _Arg1, const double _Arg2) {
    return __std_smf_cyl_neumann(_Arg1, _Arg2);
}

// FUNCTION cyl_neumannf
_NODISCARD inline float cyl_neumannf(const float _Arg1, const float _Arg2) {
    return __std_smf_cyl_neumannf(_Arg1, _Arg2);
}

// FUNCTION cyl_neumannl
_NODISCARD inline long double cyl_neumannl(const long double _Arg1, const long double _Arg2) {
    return __std_smf_cyl_neumann(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

// FUNCTION ellint_1
_NODISCARD inline double ellint_1(const double _Arg1, const double _Arg2) {
    return __std_smf_ellint_1(_Arg1, _Arg2);
}

// FUNCTION ellint_1f
_NODISCARD inline float ellint_1f(const float _Arg1, const float _Arg2) {
    return __std_smf_ellint_1f(_Arg1, _Arg2);
}

// FUNCTION ellint_1l
_NODISCARD inline long double ellint_1l(const long double _Arg1, const long double _Arg2) {
    return __std_smf_ellint_1(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

// FUNCTION ellint_2
_NODISCARD inline double ellint_2(const double _Arg1, const double _Arg2) {
    return __std_smf_ellint_2(_Arg1, _Arg2);
}

// FUNCTION ellint_2f
_NODISCARD inline float ellint_2f(const float _Arg1, const float _Arg2) {
    return __std_smf_ellint_2f(_Arg1, _Arg2);
}

// FUNCTION ellint_2l
_NODISCARD inline long double ellint_2l(const long double _Arg1, const long double _Arg2) {
    return __std_smf_ellint_2(static_cast<double>(_Arg1), static_cast<double>(_Arg2));
}

// FUNCTION ellint_3
_NODISCARD inline double ellint_3(const double _Arg1, const double _Arg2, const double _Arg3) {
    return __std_smf_ellint_3(_Arg1, _Arg2, _Arg3);
}

// FUNCTION ellint_3f
_NODISCARD inline float ellint_3f(const float _Arg1, const float _Arg2, const float _Arg3) {
    return __std_smf_ellint_3f(_Arg1, _Arg2, _Arg3);
}

// FUNCTION ellint_3l
_NODISCARD inline long double ellint_3l(const long double _Arg1, const long double _Arg2, const long double _Arg3) {
    return __std_smf_ellint_3(static_cast<double>(_Arg1), static_cast<double>(_Arg2), static_cast<double>(_Arg3));
}

// FUNCTION expint
_NODISCARD inline double expint(const double _Arg) {
    return __std_smf_expint(_Arg);
}

// FUNCTION expintf
_NODISCARD inline float expintf(const float _Arg) {
    return __std_smf_expintf(_Arg);
}

// FUNCTION expintl
_NODISCARD inline long double expintl(const long double _Arg) {
    return __std_smf_expint(static_cast<double>(_Arg));
}

// FUNCTION hermite
_NODISCARD inline double hermite(const unsigned int _Arg1, const double _Arg2) {
    return __std_smf_hermite(_Arg1, _Arg2);
}

// FUNCTION hermitef
_NODISCARD inline float hermitef(const unsigned int _Arg1, const float _Arg2) {
    return __std_smf_hermitef(_Arg1, _Arg2);
}

// FUNCTION hermitel
_NODISCARD inline long double hermitel(const unsigned int _Arg1, const long double _Arg2) {
    return __std_smf_hermite(_Arg1, static_cast<double>(_Arg2));
}

// FUNCTION laguerre
_NODISCARD inline double laguerre(const unsigned int _Arg1, const double _Arg2) {
    return __std_smf_laguerre(_Arg1, _Arg2);
}

// FUNCTION laguerref
_NODISCARD inline float laguerref(const unsigned int _Arg1, const float _Arg2) {
    return __std_smf_laguerref(_Arg1, _Arg2);
}

// FUNCTION laguerrel
_NODISCARD inline long double laguerrel(const unsigned int _Arg1, const long double _Arg2) {
    return __std_smf_laguerre(_Arg1, static_cast<double>(_Arg2));
}

// FUNCTION legendre
_NODISCARD inline double legendre(const unsigned int _Degree, const double _Value) {
    return __std_smf_legendre(_Degree, _Value);
}

// FUNCTION legendref
_NODISCARD inline float legendref(const unsigned int _Degree, const float _Value) {
    return __std_smf_legendref(_Degree, _Value);
}

// FUNCTION legendrel
_NODISCARD inline long double legendrel(const unsigned int _Degree, const long double _Value) {
    return __std_smf_legendre(_Degree, static_cast<double>(_Value));
}

// FUNCTION riemann_zeta
_NODISCARD inline double riemann_zeta(const double _Arg) {
    return __std_smf_riemann_zeta(_Arg);
}

// FUNCTION riemann_zetaf
_NODISCARD inline float riemann_zetaf(const float _Arg) {
    return __std_smf_riemann_zetaf(_Arg);
}

// FUNCTION riemann_zetal
_NODISCARD inline long double riemann_zetal(const long double _Arg) {
    return __std_smf_riemann_zeta(static_cast<double>(_Arg));
}

// FUNCTION sph_bessel
_NODISCARD inline double sph_bessel(const unsigned int _Arg1, const double _Arg2) {
    return __std_smf_sph_bessel(_Arg1, _Arg2);
}

// FUNCTION sph_besself
_NODISCARD inline float sph_besself(const unsigned int _Arg1, const float _Arg2) {
    return __std_smf_sph_besself(_Arg1, _Arg2);
}

// FUNCTION sph_bessell
_NODISCARD inline long double sph_bessell(const unsigned int _Arg1, const long double _Arg2) {
    return __std_smf_sph_bessel(_Arg1, static_cast<double>(_Arg2));
}

// FUNCTION sph_legendre
_NODISCARD inline double sph_legendre(const unsigned int _Arg1, const unsigned int _Arg2, const double _Theta) {
    return __std_smf_sph_legendre(_Arg1, _Arg2, _Theta);
}

// FUNCTION sph_legendref
_NODISCARD inline float sph_legendref(const unsigned int _Arg1, const unsigned int _Arg2, const float _Theta) {
    return __std_smf_sph_legendref(_Arg1, _Arg2, _Theta);
}

// FUNCTION sph_legendrel
_NODISCARD inline long double sph_legendrel(
    const unsigned int _Arg1, const unsigned int _Arg2, const long double _Theta) {
    return __std_smf_sph_legendre(_Arg1, _Arg2, static_cast<double>(_Theta));
}

// FUNCTION sph_neumann
_NODISCARD inline double sph_neumann(const unsigned int _Arg1, const double _Arg2) {
    return __std_smf_sph_neumann(_Arg1, _Arg2);
}

// FUNCTION sph_neumannf
_NODISCARD inline float sph_neumannf(const unsigned int _Arg1, const float _Arg2) {
    return __std_smf_sph_neumannf(_Arg1, _Arg2);
}

// FUNCTION sph_neumannl
_NODISCARD inline long double sph_neumannl(const unsigned int _Arg1, const long double _Arg2) {
    return __std_smf_sph_neumann(_Arg1, static_cast<double>(_Arg2));
}
#endif // _HAS_SPECIAL_MATH

// FUNCTION hypot (3-argument overloads)
_NODISCARD inline double hypot(const double _Dx, const double _Dy, const double _Dz) {
    return __std_smf_hypot3(_Dx, _Dy, _Dz);
}

_NODISCARD inline float hypot(const float _Dx, const float _Dy, const float _Dz) {
    return __std_smf_hypot3f(_Dx, _Dy, _Dz);
}

_NODISCARD inline long double hypot(const long double _Dx, const long double _Dy, const long double _Dz) {
    return __std_smf_hypot3(static_cast<double>(_Dx), static_cast<double>(_Dy), static_cast<double>(_Dz));
}

template <class _Ty1, class _Ty2, class _Ty3,
    enable_if_t<is_arithmetic_v<_Ty1> && is_arithmetic_v<_Ty2> && is_arithmetic_v<_Ty3>, int> = 0>
_NODISCARD inline auto hypot(const _Ty1 _Dx, const _Ty2 _Dy,
    const _Ty3 _Dz) { // N4727 [cmath.syn]/2 "Sufficient additional overloads"
                      // Note that this template is selected by overload resolution only when at least one
                      // argument is double/long double/integral but not all three are double or long double.
    using _Common      = _Common_float_type_t<_Ty1, _Common_float_type_t<_Ty2, _Ty3>>; // TRANSITION, fold expressions
    const auto _Result = __std_smf_hypot3(static_cast<double>(_Dx), static_cast<double>(_Dy), static_cast<double>(_Dz));
    return static_cast<_Common>(_Result);
}
_STD_END
#endif // _HAS_CXX17

#pragma pop_macro("new")
_STL_RESTORE_CLANG_WARNINGS
#pragma warning(pop)
#pragma pack(pop)

#endif // RC_INVOKED
#endif // _CMATH_

/*
 * Copyright (c) by P.J. Plauger. All rights reserved.
 * Consult your license regarding permissions and restrictions.
V6.50:0009 */
